home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / tools / sources / pat_sel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  9.2 KB  |  337 lines
  1. /*****************************************************************************
  2.   FILE           : pat_sel.c
  3.   SHORTNAME      : 
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : Pattern Selector
  7.   NOTES          :
  8.  
  9.   AUTHOR         : Stefan Broeckel, Tobias Soyez 
  10.   DATE           : 30.07.92
  11.   VERSION        : 1.0
  12.  
  13.   CHANGED BY     : 
  14.   IDENTIFICATION : @(#)pat_sel.c    1.3 2/28/94
  15.   SCCS VERSION   : 1.3
  16.   LAST CHANGE    : 2/28/94
  17.  
  18.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  19.  
  20. ******************************************************************************/
  21.  
  22.  
  23. /******************************************************************************/
  24. /* included headers                                                           */
  25. /******************************************************************************/
  26.  
  27. #include <stdio.h>
  28. #include <time.h>
  29.  
  30.  
  31. /******************************************************************************/
  32. /* constants                                                                  */
  33. /******************************************************************************/
  34.  
  35. #define NO_ERROR      0
  36. #define BAD_PAT_FILE  1
  37. #define WRITE_ERR     2
  38. #define UNEXP_EOF     3
  39.  
  40.  
  41. /******************************************************************************/
  42. /* global variables                                                           */
  43. /******************************************************************************/
  44.  
  45. FILE  *in_no_file   ;
  46. FILE  *in_pat_file  ;
  47. FILE  *out_pat_file ;
  48.  
  49.  
  50. static char *patHeader[] =
  51. {  
  52.   "SNNS pattern definition file %s\n",
  53.   "generated at",
  54.   "No. of patterns     : %d\n",
  55.   "No. of input units  : %d\n",
  56.   "No. of output units : %d\n"
  57. } ;
  58.  
  59.  
  60.  
  61. /******************************************************************************/
  62. /* function skip_comment                                                      */
  63. /******************************************************************************/
  64.  
  65. skip_comment ()
  66.   
  67.   {
  68.     register int  c ;
  69.     int           q ;
  70.  
  71.     q    = 1 ;
  72.  
  73.     while (q != 3)
  74.     {
  75.       c = getc (in_pat_file) ;
  76.  
  77.       switch (c)
  78.       {
  79.         case ' '  : break ;  
  80.         case '\n' : if (q == 2) q = 3 ; break ;
  81.         case '#'  : if (q == 1) q = 2 ; break ;
  82.         case EOF  :             q = 3 ; break ;
  83.         default   : if (q == 1) q = 3 ; break ;
  84.       }
  85.     }
  86.  
  87.     ungetc (c, in_pat_file) ;
  88.   }
  89.  
  90.  
  91.  
  92. /******************************************************************************/
  93. /* function read_file_header                                                  */
  94. /******************************************************************************/
  95.  
  96. int read_file_header (no_of_patterns, no_of_input_units, no_of_output_units,
  97.                       version)
  98.  
  99.   int  *no_of_patterns     ;
  100.   int  *no_of_input_units  ;
  101.   int  *no_of_output_units ;
  102.   char *version            ;
  103.  
  104.   {
  105.     char  dstring [255] ;
  106.  
  107.  
  108.     skip_comment() ;
  109.  
  110.     if (fscanf(in_pat_file, patHeader[0], version) == 1)
  111.     { 
  112.       if (fscanf(in_pat_file, patHeader[1]) != 0)    return (BAD_PAT_FILE) ;
  113.       if (fgets (dstring, 254, in_pat_file) == NULL) return (BAD_PAT_FILE) ;
  114.       skip_comment() ;
  115.       if (fscanf(in_pat_file, patHeader[2], no_of_patterns)     != 1)
  116.          return (BAD_PAT_FILE) ;
  117.       if (fscanf(in_pat_file, patHeader[3], no_of_input_units)  != 1)
  118.          return (BAD_PAT_FILE) ;
  119.       if (fscanf(in_pat_file, patHeader[4], no_of_output_units) != 1)
  120.          return (BAD_PAT_FILE) ;
  121.     }
  122.     else
  123.     {
  124.       sprintf (version, "%s", "V1.4-3D") ;
  125.       if (fscanf (in_pat_file, "%d%d%d", no_of_patterns, no_of_input_units,
  126.           no_of_output_units) != 3) return (BAD_PAT_FILE) ;
  127.     }
  128.  
  129.     return (NO_ERROR) ;
  130.   }
  131.  
  132.  
  133.  
  134. /******************************************************************************/
  135. /* function write_file_header                                                 */
  136. /******************************************************************************/
  137.  
  138. int write_file_header (no_of_patterns, no_of_input_units, no_of_output_units,
  139.                        version)
  140.  
  141.   int  no_of_patterns     ;
  142.   int  no_of_input_units  ;
  143.   int  no_of_output_units ;
  144.   char *version           ;
  145.  
  146.  
  147.   {
  148.     time_t  clock ;
  149.  
  150.  
  151.     fprintf(out_pat_file, patHeader[0], version) ;
  152.     fprintf(out_pat_file, patHeader[1]) ;
  153.     (void) time (&clock) ;
  154.     fprintf(out_pat_file, " %s\n", ctime (&clock)) ;
  155.     fprintf(out_pat_file, patHeader[2], no_of_patterns    ) ;
  156.     fprintf(out_pat_file, patHeader[3], no_of_input_units ) ;
  157.     fprintf(out_pat_file, patHeader[4], no_of_output_units) ;
  158.     fprintf(out_pat_file, "\n") ;
  159.     return (NO_ERROR) ;
  160.   }
  161.  
  162.  
  163.  
  164. /******************************************************************************/
  165. /* main program                                                               */
  166. /******************************************************************************/
  167.       
  168. main (argc, argv)
  169.  
  170. int  argc    ;
  171. char *argv[] ;
  172.  
  173. { 
  174.   float  *output_pattern    ;
  175.   float  *input_pattern     ;
  176.   char   version[255]       ;
  177.   int    no_of_patterns     ;
  178.   int    no_of_input_units  ;
  179.   int    no_of_output_units ;
  180.   int    no_of_sel_pat      ;
  181.   int    pat_no             ;
  182.   int    act_pat            ;
  183.   int    error, i, j        ;
  184.   
  185.  
  186.   error = NO_ERROR ;
  187.  
  188.   if (argc != 4)
  189.   {  
  190.     fprintf (stderr, "usage: %s <no_file> <in_pat_file> <out_pat_file>\n",
  191.              argv[0]); 
  192.     return ;
  193.   }
  194.  
  195.   
  196.   if ((in_no_file   = fopen(argv[1], "r")) == (FILE *) NULL) 
  197.   { 
  198.     fprintf(stderr, "error: can't read file %s\n", argv[1]) ;
  199.     return ;
  200.   }
  201.   
  202.   if ((in_pat_file  = fopen(argv[2], "r")) == (FILE *) NULL)
  203.   { 
  204.     fprintf(stderr, "error: can't read file %s\n", argv[2]) ;
  205.     fclose (in_no_file) ;
  206.     return ;
  207.   }
  208.  
  209.   if ((out_pat_file = fopen(argv[3], "r")) != (FILE *) NULL)
  210.   {
  211.     fclose(out_pat_file) ;
  212.     fprintf (stderr, "overwrite %s (y/n) ? ", argv[3]) ;
  213.     if (getc(stdin) != 'y') return ; 
  214.   }
  215.  
  216.   if ((out_pat_file = fopen(argv[3], "w")) == (FILE *) NULL)
  217.   {
  218.     fprintf(stderr, "error: can't create file %s\n", argv[3]) ;
  219.     fclose (in_no_file)  ;
  220.     fclose (in_pat_file) ;
  221.     return ;
  222.   }
  223.  
  224.   
  225.   act_pat       = 1 ; 
  226.   no_of_sel_pat = 0 ;
  227.  
  228.   /* number of entries in the number file */
  229.   while (fscanf(in_no_file, "%d", &pat_no) == 1) no_of_sel_pat++ ;
  230.   fseek (in_no_file, 0, 0) ;
  231.  
  232.   if (read_file_header  (&no_of_patterns, &no_of_input_units,
  233.       &no_of_output_units, version) != 0) error = BAD_PAT_FILE ;
  234.    
  235.   if (write_file_header (no_of_sel_pat, no_of_input_units,
  236.       no_of_output_units, version) != 0)  error = WRITE_ERR ; 
  237.  
  238.   input_pattern  = (float *) malloc(no_of_input_units  * sizeof(float)) ;
  239.   output_pattern = (float *) malloc(no_of_output_units * sizeof(float)) ;
  240.  
  241.   /* select patterns */
  242.   for (i = 1 ; (i <= no_of_sel_pat) && (error == NO_ERROR) ; i++)
  243.   { 
  244.     if (fscanf (in_no_file, "%d", &pat_no) == EOF) error == UNEXP_EOF ;
  245.   
  246.     /* search pattern */
  247.     while ((act_pat != pat_no) && (error == NO_ERROR))
  248.     {  
  249.       for (j = 0 ; j < no_of_input_units ; j++)
  250.       {
  251.         skip_comment () ;
  252.         if (fscanf (in_pat_file, "%*f") == EOF) error = UNEXP_EOF ;
  253.       }  
  254.       for (j = 0 ; j < no_of_output_units ; j++)
  255.       {
  256.         skip_comment () ;
  257.         if (fscanf (in_pat_file, "%*f") == EOF) error = UNEXP_EOF ;
  258.       } 
  259.       act_pat++ ;       
  260.     }
  261.     
  262.     /* read pattern */
  263.     if (error == NO_ERROR)
  264.     {
  265.       for (j = 0 ; j < no_of_input_units ; j++)
  266.       {
  267.         skip_comment () ;
  268.         if (fscanf (in_pat_file, "%f", &input_pattern[j]) == EOF)
  269.             error = UNEXP_EOF ;
  270.       }  
  271.       for (j = 0 ; j < no_of_output_units ; j++)
  272.       {
  273.         skip_comment () ;
  274.         if (fscanf (in_pat_file, "%f", &output_pattern[j]) == EOF)
  275.             error = UNEXP_EOF ;
  276.       }
  277.       
  278.       act_pat++ ;
  279.  
  280.       /* write pattern */
  281.       if (error == NO_ERROR)
  282.       {
  283.         fprintf (out_pat_file, "#%d\n", i) ;
  284.  
  285.         for (j = 0 ; j < no_of_input_units ; j++)
  286.         {
  287.           if      (input_pattern[j] == 0.0) fprintf (out_pat_file, "0 ") ;
  288.           else if (input_pattern[j] == 1.0) fprintf (out_pat_file, "1 ") ;
  289.           else    fprintf (out_pat_file, "%f ", input_pattern[j]) ;
  290.  
  291.           if ((j % 10) == 9) fprintf (out_pat_file, "\n") ;
  292.         } 
  293.         fprintf (out_pat_file, "\n") ;
  294.  
  295.         for (j = 0 ; j < no_of_output_units ; j++)
  296.         {
  297.           if      (output_pattern[j] == 0.0) fprintf (out_pat_file, "0 ") ;
  298.           else if (output_pattern[j] == 1.0) fprintf (out_pat_file, "1 ") ;
  299.           else    fprintf (out_pat_file, "%f ", output_pattern[j]) ;
  300.  
  301.           if ((j % 10) == 9) fprintf (out_pat_file, "\n") ;
  302.         } 
  303.         fprintf (out_pat_file, "\n") ;
  304.       }
  305.     }
  306.   }
  307.  
  308.   switch (error)
  309.   {
  310.     case BAD_PAT_FILE : fprintf(stderr, "error: bad pattern file\n")       ;
  311.                         break ;
  312.     case WRITE_ERR    : fprintf(stderr, "error: write error\n")            ;
  313.                         break ;
  314.     case UNEXP_EOF    : fprintf(stderr, "error: unexpected end of file\n") ;
  315.                         break ;
  316.     default           : break ;
  317.   }
  318.  
  319.   free (input_pattern)  ;
  320.   free (output_pattern) ;
  321.  
  322.   fclose (in_no_file)   ;
  323.   fclose (in_pat_file)  ;
  324.   fclose (out_pat_file) ;
  325. }
  326.  
  327.  
  328. /******************************************************************************/
  329. /* end of file                                                                */
  330. /******************************************************************************/
  331.  
  332.  
  333.  
  334.  
  335.  
  336.  
  337.